package io.renren.modules.archive.controller;

import java.util.*;
import java.util.stream.Collectors;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import io.renren.common.annotation.SysLog;
import io.renren.common.exception.RRException;
import io.renren.common.utils.Constant;
import io.renren.modules.archive.entity.*;
import io.renren.modules.archive.service.*;
import io.renren.modules.sys.entity.SysMenuEntity;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import io.renren.common.utils.PageUtils;
import io.renren.common.utils.R;



/**
 * ${comments}
 *
 * @author lizeliang
 * @email 2749877017@qq.com
 * @date 2023-08-29 13:06:15
 */
@RestController
@RequestMapping("archive/archivecollect")
public class ArchiveCollectController {
    @Autowired
    private ArchiveCollectService archiveCollectService;
    @Autowired
    private DictionaryService dictionaryService;
    @Autowired
    private MeetingtypeService meetingtypeService;
    @Autowired
    private MeetingDetailService meetingDetailService;
    @Autowired
    private NdJgMenuService ndJgMenuService;


    /**
     * 列表
     */
    @RequestMapping("/list")
//    @RequiresPermissions("archive:archivecollect:list")
    public R list(@RequestParam Map<String, Object> params){
        PageUtils page = archiveCollectService.queryPage(params);

        return R.ok().put("page", page);
    }

    /**
     * 导航菜单
     */
    @GetMapping("/getArchivecollectList")
    public R getArchivecollectList(){
        List<ArchiveCollectEntity> menuList = archiveCollectService.getArchivecollectAllList();

        return R.ok().put("menuList", menuList);
    }

    /**
     * 信息
     */
    @GetMapping("/info/{menuId}")
//    @RequiresPermissions("archive:archivecollect:info")
    public R info(@PathVariable("menuId") String menuId){
		ArchiveCollectEntity archiveCollect = archiveCollectService.getById(menuId);

        return R.ok().put("archiveCollect", archiveCollect);
    }

    /**
     * 保存
     */
    @RequestMapping("/save")
    public R save(@RequestBody ArchiveCollectEntity archiveCollect){
        //数据校验
        verifyForm(archiveCollect);
        //数据校验
        verifyForm(archiveCollect);
        if (archiveCollect.getParentId()==0){
            archiveCollect.setLevel("1");
        }else{
            ArchiveCollectEntity a=  archiveCollectService.getById(archiveCollect.getParentId());
            try {
                String numStr ="";
                int num = Integer.parseInt(a.getLevel());
                num++;
                numStr = Integer.toString(num);
                archiveCollect.setLevel(numStr);
            } catch (NumberFormatException e) {
                System.out.println("无法将输入的字符串转换为整数");
            }
        }
		archiveCollectService.save(archiveCollect);

        return R.ok();
    }

    /**
     * 修改
     */
    @RequestMapping("/update")
//    @RequiresPermissions("archive:archivecollect:update")
    public R update(@RequestBody ArchiveCollectEntity archiveCollect){
        //数据校验
        verifyForm(archiveCollect);
        if (archiveCollect.getParentId()==0){
            archiveCollect.setLevel("1");
        }else{
          ArchiveCollectEntity a=  archiveCollectService.getById(archiveCollect.getParentId());
            try {
                String numStr ="";
                int num = Integer.parseInt(a.getLevel());
                num++;
                numStr = Integer.toString(num);
                archiveCollect.setLevel(numStr);
            } catch (NumberFormatException e) {
                System.out.println("无法将输入的字符串转换为整数");
            }
        }

		archiveCollectService.updateById(archiveCollect);

        return R.ok();
    }

    /**
     * 删除
     */
    @RequestMapping("/delete")
//    @RequiresPermissions("archive:archivecollect:delete")
    public R delete(@RequestBody String[] menuIds){
		archiveCollectService.removeByIds(Arrays.asList(menuIds));

        return R.ok();
    }


    /**
     * 菜单对应的事项类型
     */
    @RequestMapping("/query")
    public R query(@RequestParam Map<String, Object> params){

        List<ArchiveCollectEntity> menuList=archiveCollectService.queryLocalMenu(params);
        String onesxlx= menuList.get(menuList.size()-1).getValue();
        String twosxlx= menuList.get(menuList.size()-2).getValue();
        String threesxlx= menuList.get(0).getValue();
        String dictionaryType =params.get("dict")+onesxlx+twosxlx+threesxlx;
        List<DictionaryEntity> dictList=dictionaryService.getDictDataListByType(dictionaryType);
        return R.ok()
                .put("onesxlx",onesxlx)
                .put("twosxlx",twosxlx)
                .put("threesxlx",threesxlx)
                .put("dictList",dictList)

                ;
    }


    /**
     * 所有菜单列表
     */
    @GetMapping("/collectmenuList")
    public List<ArchiveCollectEntity> collectmenuList(){
        LambdaQueryWrapper<ArchiveCollectEntity> lambdaQueryWrapper= Wrappers.lambdaQuery();
        lambdaQueryWrapper.in(ArchiveCollectEntity::getLevel, Arrays.asList("1", "2", "3"));
        List<ArchiveCollectEntity> menuList = archiveCollectService.list(lambdaQueryWrapper);

        //查询完成 对此list直接排序
        Collections.sort(menuList);

        HashMap<Long, ArchiveCollectEntity> menuMap = new HashMap<>(12);
        for (ArchiveCollectEntity s : menuList) {
            menuMap.put(s.getMenuId(), s);
        }
        for (ArchiveCollectEntity s : menuList) {
            ArchiveCollectEntity parent = menuMap.get(s.getParentId());
            if (Objects.nonNull(parent)) {
                s.setParentName(parent.getName());
            }

        }


        return menuList;
    }



    /**
     * 删除
     */
    @PostMapping("/deleteById/{menuId}")
    public R deleteById(@PathVariable("menuId") long menuId){

        //判断是否有子菜单或按钮
        List<ArchiveCollectEntity> menuList = archiveCollectService.queryListParentId(menuId);
        if(menuList.size() > 0){
            return R.error("请先删除子菜单或按钮");
        }

        archiveCollectService.delete(menuId);

        return R.ok();
    }


    /**
     * 选择菜单(添加、修改菜单)
     */
    @GetMapping("/select")
    public R select(){
        LambdaQueryWrapper<ArchiveCollectEntity> lambdaQueryWrapper=Wrappers.lambdaQuery();
        lambdaQueryWrapper.in(ArchiveCollectEntity::getLevel,Arrays.asList("1","2"));
        List<ArchiveCollectEntity> menuList= archiveCollectService.list(lambdaQueryWrapper);


        //添加顶级菜单
        ArchiveCollectEntity root = new ArchiveCollectEntity();
        root.setMenuId(0L);
        root.setName("首菜单");
        root.setParentId(-1L);
        root.setOpen(true);
        menuList.add(root);

        return R.ok().put("menuList", menuList);
    }

    /**
     * 验证参数是否正确
     */
    private void verifyForm(ArchiveCollectEntity menu){
        if(StringUtils.isBlank(menu.getName())){
            throw new RRException("菜单名称不能为空");
        }

        if(menu.getParentId() == null){
            throw new RRException("上级菜单不能为空");
        }
        if(menu.getValue() == null){
            throw new RRException("菜单值不能为空");
        }
        //菜单
        if(menu.getParentId() == 0){
            if(StringUtils.isBlank(menu.getUrl())){
                throw new RRException("菜单URL不能为空");
            }
        }


    }

    @RequestMapping("/formatMeetingType")
    public R formatMeetingType() {
        try {
            // 查询level为"4"的ArchiveCollectEntity列表
            LambdaQueryWrapper<ArchiveCollectEntity> archiveCollectWrapper = Wrappers.lambdaQuery();
            archiveCollectWrapper.eq(ArchiveCollectEntity::getLevel, "4");
            List<ArchiveCollectEntity> archiveCollectList = archiveCollectService.list(archiveCollectWrapper);

            // 如果没有查询到任何记录，则直接返回成功响应或抛出异常（根据业务需求决定）
            if (archiveCollectList.isEmpty()) {
                throw new IllegalArgumentException("No ArchiveCollectEntity records found with level '4'.");
            }

            // 提取menuIds
            List<Long> menuIds = archiveCollectList.stream().map(ArchiveCollectEntity::getMenuId).collect(Collectors.toList());

            // 删除对应的ArchiveCollectEntity记录（注意：这里会删除所有level为"4"的记录，请确认这是否符合业务需求）
            boolean deleteCountArchive = archiveCollectService.remove(archiveCollectWrapper);
            if (deleteCountArchive ==false) {
                // 没有记录被删除，可能是数据已被其他操作删除，这里可以记录日志或抛出异常（根据业务需求决定）
            }

            // 删除MeetingtypeEntity和MeetingDetailEntity记录（注意：这里会删除所有记录，请确认这是否符合业务需求）
            // 如果不需要删除所有记录，应该添加适当的查询条件
            LambdaQueryWrapper<MeetingtypeEntity> meetingtypeWrapper = Wrappers.lambdaQuery();
             meetingtypeService.remove(meetingtypeWrapper); // 注意这里我修正了服务层实例名称的拼写错误


            LambdaQueryWrapper<MeetingDetailEntity> meetingDetailWrapper = Wrappers.lambdaQuery();
           meetingDetailService.remove(meetingDetailWrapper);


            // 如果menuIds为空，则不执行NdJgMenuEntity的删除操作
            if (!menuIds.isEmpty()) {
                LambdaQueryWrapper<NdJgMenuEntity> ndJgMenuWrapper = Wrappers.lambdaQuery();
                ndJgMenuWrapper.in(NdJgMenuEntity::getMenuId, menuIds);
               ndJgMenuService.remove(ndJgMenuWrapper);

            } else {
                // 处理menuIds为空的情况（根据业务需求决定是否需要记录日志或抛出异常）
                // 当前实现中，由于在前面已经检查了archiveCollectList是否为空，所以这里不会执行到（除非在提取menuIds和执行删除之间有其他代码修改了menuIds列表）
            }

            // 返回成功响应（根据实际业务需求，可能需要在响应中包含更多信息，如删除的记录数等）
            return R.ok(); // 这里假设R.ok()表示操作成功的响应，实际使用时可能需要根据具体的业务逻辑来调整返回值或包含额外信息

        } catch (Exception e) {
            // 处理异常情况（根据业务需求记录日志、返回错误信息或执行其他操作）
            // 这里只是一个简单的示例，实际使用时可能需要更详细的异常处理逻辑
            return R.error(e.getMessage()); // 假设R.error()用于包装错误信息并返回给调用者（实际使用时需要根据具体的响应类来调整）
        }
    }
}